home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / ntfs / index.h < prev    next >
C/C++ Source or Header  |  2005-10-18  |  5KB  |  125 lines
  1. /*
  2.  * index.h - Defines for NTFS index handling.  Part of the Linux-NTFS project.
  3.  *
  4.  * Copyright (c) 2004 Anton Altaparmakov
  5.  * Copyright (c) 2005 Yura Pakhuchiy
  6.  *
  7.  * This program/include file is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU General Public License as published
  9.  * by the Free Software Foundation; either version 2 of the License, or
  10.  * (at your option) any later version.
  11.  *
  12.  * This program/include file is distributed in the hope that it will be
  13.  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  14.  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this program (in the main directory of the Linux-NTFS
  19.  * distribution in the file COPYING); if not, write to the Free Software
  20.  * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21.  */
  22.  
  23. #ifndef _NTFS_INDEX_H
  24. #define _NTFS_INDEX_H
  25.  
  26. #include "attrib.h"
  27. #include "types.h"
  28. #include "layout.h"
  29. #include "inode.h"
  30. #include "mft.h"
  31.  
  32. /**
  33.  * @ni:        inode containing the @entry described by this context
  34.  * @name:    name of the index described by this context
  35.  * @name_len:    length of the index name
  36.  * @entry:    index entry (points into @ir or @ia)
  37.  * @data:    index entry data (points into @entry)
  38.  * @data_len:    length in bytes of @data
  39.  * @is_in_root:    TRUE if @entry is in @ir and FALSE if it is in @ia
  40.  * @ir:        index root if @is_in_root and NULL otherwise
  41.  * @actx:    attribute search context if @is_in_root and NULL otherwise
  42.  * @ia:        index block if @is_in_root is FALSE and NULL otherwise
  43.  * @ia_na:    opened INDEX_ALLOCATION attribute
  44.  * @ia_vcn:    VCN from which @ia where read from
  45.  * @ia_dirty:    TRUE if index block was changed
  46.  * @block_size:    index block size
  47.  *
  48.  * @ni is the inode this context belongs to.
  49.  *
  50.  * @entry is the index entry described by this context.  @data and @data_len
  51.  * are the index entry data and its length in bytes, respectively.  @data
  52.  * simply points into @entry.  This is probably what the user is interested in.
  53.  *
  54.  * If @is_in_root is TRUE, @entry is in the index root attribute @ir described
  55.  * by the attribute search context @actx and inode @ni.  @ia, @ia_vcn and
  56.  * @ia_dirty are undefined in this case.
  57.  *
  58.  * If @is_in_root is FALSE, @entry is in the index allocation attribute and @ia
  59.  * and @ia_vcn point to the index allocation block and VCN where it's placed,
  60.  * respectively. @ir and @actx are NULL in this case. @ia_na is opened
  61.  * INDEX_ALLOCATION attribute. @ia_dirty is TRUE if index block was changed and
  62.  * FALSE otherwise.
  63.  *
  64.  * To obtain a context call ntfs_index_ctx_get().
  65.  *
  66.  * When finished with the @entry and its @data, call ntfs_index_ctx_put() to
  67.  * free the context and other associated resources.
  68.  *
  69.  * If the index entry was modified, call ntfs_index_entry_mark_dirty() before
  70.  * the call to ntfs_index_ctx_put() to ensure that the changes are written
  71.  * to disk.
  72.  */
  73. typedef struct {
  74.     ntfs_inode *ni;
  75.     ntfschar *name;
  76.     u32 name_len;
  77.     INDEX_ENTRY *entry;
  78.     void *data;
  79.     u16 data_len;
  80.     BOOL is_in_root;
  81.     INDEX_ROOT *ir;
  82.     ntfs_attr_search_ctx *actx;
  83.     INDEX_ALLOCATION *ia;
  84.     ntfs_attr *ia_na;
  85.     VCN ia_vcn;
  86.     BOOL ia_dirty;
  87.     u32 block_size;
  88. } ntfs_index_context;
  89.  
  90. extern ntfs_index_context *ntfs_index_ctx_get(ntfs_inode *ni,
  91.                         ntfschar *name, u32 name_len);
  92. extern void ntfs_index_ctx_put(ntfs_index_context *ictx);
  93. extern void ntfs_index_ctx_reinit(ntfs_index_context *ictx);
  94.  
  95. extern int ntfs_index_lookup(const void *key, const int key_len,
  96.         ntfs_index_context *ictx);
  97.  
  98. extern int ntfs_index_add_filename(ntfs_inode *ni, FILE_NAME_ATTR *fn,
  99.         MFT_REF mref);
  100. extern int ntfs_index_rm(ntfs_index_context *ictx);
  101.  
  102. /**
  103.  * ntfs_index_entry_mark_dirty - mark an index entry dirty
  104.  * @ictx:    ntfs index context describing the index entry
  105.  *
  106.  * Mark the index entry described by the index entry context @ictx dirty.
  107.  *
  108.  * If the index entry is in the index root attribute, simply mark the inode
  109.  * containing the index root attribute dirty.  This ensures the mftrecord, and
  110.  * hence the index root attribute, will be written out to disk later.
  111.  *
  112.  * If the index entry is in an index block belonging to the index allocation
  113.  * attribute, set ia_dirty to TRUE, thus index block will be updated during
  114.  * ntfs_index_ctx_put.
  115.  */
  116. static inline void ntfs_index_entry_mark_dirty(ntfs_index_context *ictx)
  117. {
  118.     if (ictx->is_in_root)
  119.         ntfs_inode_mark_dirty(ictx->actx->ntfs_ino);
  120.     else
  121.         ictx->ia_dirty = TRUE;
  122. }
  123.  
  124. #endif /* _NTFS_INDEX_H */
  125.